import java.io.*;
import java.util.ArrayList;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException{
        //牛客网WY22 Fibonacci数列
        BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
        String s=reader.readLine();
        int n=Integer.parseInt(s);
        int[] fp=new int[1000000];
        fp[0]=1;
        fp[1]=1;
        int left=1;
        int right=0;
        for(int i=2;i<=1000000;i++){
            fp[i]=fp[i-1]+fp[i-2];
            if(fp[i]>n){
                right=fp[i];
                break;
            }
            left=fp[i];
        }
        System.out.print(Math.min(n-left,right-n));

    }


    //NC242 单词搜索
    public boolean exist (String[] board, String word) {
        int rows = board.length;
        int cols = board[0].length();
        char[][] ch = new char[rows][cols];

        // 将字符串数组转换为字符数组
        for (int i = 0; i < rows; i++) {
            ch[i] = board[i].toCharArray();
        }

        // 遍历整个字符数组，尝试从每个位置开始搜索单词
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (ch[i][j] == word.charAt(0) && dfs(ch, word, i, j, 0)) {
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * 深度优先搜索
     * @param board 字符数组
     * @param word 目标单词
     * @param row 当前行
     * @param col 当前列
     * @param index 当前单词的字符索引
     * @return 是否找到
     */
    private boolean dfs(char[][] board, String word, int row, int col, int index) {
        // 如果单词已经完全匹配
        if (index == word.length()) {
            return true;
        }

        // 边界条件检查
        if (row < 0 || col < 0 || row >= board.length || col >= board[0].length ||
                board[row][col] != word.charAt(index)) {
            return false;
        }

        // 标记当前格子已经访问过
        char temp = board[row][col];
        board[row][col] = '#';  // 使用一个特殊字符标记已访问的格子

        // 进行四个方向的递归搜索
        boolean found = dfs(board, word, row + 1, col, index + 1) ||  // 向下
                dfs(board, word, row - 1, col, index + 1) ||  // 向上
                dfs(board, word, row, col + 1, index + 1) ||  // 向右
                dfs(board, word, row, col - 1, index + 1);    // 向左

        // 恢复当前格子的字符
        board[row][col] = temp;

        return found;
    }



    //BC140 杨辉三角
    public static void main2(String[] args) throws IOException{
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String s = reader.readLine();
        int n = Integer.parseInt(s);
        List<List<Integer>> list = new ArrayList<>();
        for(int i=0;i<n;i++){
            List<Integer> temp=new ArrayList<>();
            for(int j=0;j<=i;j++){
                if(j==0||i==j){
                    temp.add(1);
                }else{
                    temp.add(list.get(i-1).get(j)+list.get(i-1).get(j-1));
                }
            }
            list.add(temp);
        }
        //题目要求每个数输出域宽为5。
        for(List<Integer> list1:list){
            for(Integer num:list1){
                //注意是printf
                System.out.printf("%5d",num);
            }
            System.out.println();
        }

    }
}